// // 扩展运算符
// // 解析数组
// console.log(...[1,2,3])
// // 复制数组
// let a = [1,2,3]
// let b = [...a]
// b.push(4)
// console.log(a,b)
// // 合并数组
// let c = [1,2,3];
// let d = [4,5,6];
// let cd = [...c,...d];
// console.log(cd);


// Array-from
// let j1 = {
//     '0': [1, 2, 3],
//     '1': '222',
//     length: 2
// }
// let j2 = {
//     '2': [1, 2, 3],
//     '1': '222',
//     length: 2
// }
// let l = 'hello';
// console.log(Array.from(j1))
// console.log(Array.from(j2))
// console.log(Array.from(l))

// Array-of
// console.log(Array.of(1,2,3,));
// console.log(Array.of(1));
// console.log(Array.of('1','333',''));

// console.log(new Array(3));

//4、copyWithin
// console.log([1, 2, 3, 4, 5].copyWithin(0, 4))   //[5, 2, 3, 4, 5]

// find
// let a = [1, 2, 4, -1].find((val, index, arr) => {
//     console.log(val, index, arr)
//     return val < 0
// })
// console.log(a); //-1

// findindex
// let b = [1, 2, 4, -6].findIndex((val, index, arr) => {
//     console.log(val, index, arr)
//     return val < 0
// })
// console.log(b); //3


// fill
// let a = [1,2,3];
// console.log(a.fill(7));

// let b = new Array(3).fill(7);
// b[0] =1
// console.log(b);

// let c = new Array(3).fill({name:'123'});
// c[0].name = '456';
// console.log(c);

// let d = new Array(3).fill([]);
// d[0].push(2);
// console.log(d)


// // includes
// let arr = [1,2,3]
// let j = 'hello';
// // 查找字符串
// console.log('字符串 '+j.includes('l'))
// // 查找数组
// console.log('includes '+arr.includes(2));
// console.log('includes 字符串 '+arr.includes('2'));
// console.log('indexOf '+arr.indexOf(2));
// console.log('indexOf 字符串 '+arr.indexOf('2'));
// console.log('includes 不匹配的数 '+arr.includes(6));
// console.log('indexOf 不匹配的数 '+arr.indexOf(6));
// // 支持从第几个开始判断
// console.log('位置 '+arr.includes(2,2)); //false

// // 区别 includes 与 indexOf 如果一样就没有必要在出一个新方法了对吧
// let n = [NaN];
// console.log('includes NaN '+n.includes(NaN));
// console.log('indexOf NaN '+n.indexOf(NaN));

// //优势
// // 1、语义化明显，返回 true 和 false 和直接在判断语句中使用
// // 2、无法判断出 NaN 


// // 循环
// let arr = ['a', 'b', 'c', 'd'];
// let obj = {
//     a: 'a1',
//     b: 'b1',
//     c: 'c1',
// }

// // for循环
// for (let i = 0; i < arr.length; i++) {
//     console.log('for循环 ' + arr[i])
//     console.log(i);
//     // break
// }
// // for 循环优化版  速度最快版
// for (let i = 0, len = arr.length; i < len; i++) {
//     console.log('for 循环优化版 缓存length ' + arr[i])
// }

// // forin 循环 与 for 循环的区别  他的key 是使用的 字符串  不是 数字类型  更适合用于数组
// // key 输出的是 对应的 键名
// // break 和 retuan false 不能打断
// for (const key in arr) {
//     console.log('forin 循环 数组 ' + arr[key])
//     console.log(key)
// }
// for (const key in obj) {
//     console.log('forin 循环 对象 ' + obj[key])
// }

// // es5 的 foreach 循环 回调函数里面传入 e 循环获取的值  i 当前第几个  不建议使用
// // break 和 retuan false 不能打断
// arr.forEach((e, i) => {
//     console.log('foreach 循环 ' + e, i)
// });

// // for of 循环  i 输出的是 对应的值
// for (const i of arr) {
//     console.log('for of 循环 ' + i)
//     // break
// }
// // for of循环 values
// // for (const i of arr.values()) {
// //     console.log('for of 循环 values ' + i)
// // }
// // 报错无法执行
// // for of循环 keys
// // 与for循环类型  i 对应的 第几个  数字类型
// for (let i of arr.keys()) {
//     console.log('for of 循环 keys ' + i)
//     console.log(i)
//     // break
// }
// // for of循环 entries
// for (let [i,e] of arr.entries()) {
//     console.log('for of 循环 entries ' + i,e)
//     console.log(i)
// }

// // for of 有个好玩的  可以手动用 next 去遍历
// let len = arr.entries();
// console.log(len.next().value)
// console.log(len.next().value)
// console.log(len.next().value)


// // map 循环
// // 回调函数  可以 新建一个你改变的数组 无法 break
// let arr1 = arr.map((e,i)=>{
//     console.log(e,i)
//     return e+2
// })
// console.log(arr1,arr)